package main

import (
	"fmt"
	"sort"
)

//sort包提供了排序切片和用户自定义数据集以及相关功能的函数。
//sort包主要针对[]int、[]float64、[]string、以及其他自定义切片的排序。
/*结构体
type IntSlice struct
type Float64Slice
type StringSlice*/
/*函数
func Ints(a []int)
func IntsAreSorted(a []int) bool
func SearchInts(a []int, x int) int
func Float64s(a []float64)
func Float64sAreSorted(a []float64) bool
func SearchFloat64s(a []float64, x float64) int
func SearchFloat64s(a []float64, x float64) bool
func Strings(a []string)
func StringsAreSorted(a []string) bool
func SearchStrings(a []string, x string) int
func Sort(data Interface)
func Stable(data Interface)
func Reverse(data Interface) Interface
func ISSorted(data Interface) bool
func Search(n int, f func(int) bool) int*/
//接口 type interface
type Interface interface {
	Len() int           // Len方法返回集合中的元素个数
	Less(i, j int) bool // i>j，该方法返回索引i的元素是否比索引j的元素小
	Swap(i, j int)      // 交换i，j的值
}

// 实例
type NewInts []uint

func (n NewInts) Len() int {
	return len(n)
}

func (n NewInts) Less(i, j int) bool {
	fmt.Println(i, j, n[i] < n[j], n)
	return n[i] < n[j]
}

func (n NewInts) Swap(i, j int) {
	n[i], n[j] = n[j], n[i]
}

func main() {
	n := []uint{1, 3, 2}
	sort.Sort(NewInts(n))
	fmt.Println(n)
}

/*结构体
三种结构体的方法都是一样的，只是分别针对int切片、float64切片、strings切片这三种不同的类型。
然后三种结果的都有五种公开方法
func (p xxxSlice) Len() int //切片长度
func (p xxxSlice) Less(i, j int) bool
func (p xxxSlice) Swap(i, j int)
func (p xxxSlice) Search(x xxx) int
// 这个和后面那个功能一样
func (p xxxSlice) Sort()*/
//综合实例
func maimnn() {
	//[]float64:
	f := []float64{1.1, 4.4, 5.5, 3.3, 2.2}
	sort.Float64s(f)
	fmt.Printf("f: %v\n", f)

	//[]int:
	f2 := []int{3, 5, 1, 2, 4}
	sort.Ints(f2)
	fmt.Printf("f: %v\n", f2)

	//[]string:
	ls := []string{"tom", "jerry", "bar", "eog", "zler"}
	fmt.Println(ls)
	sort.Strings(ls)
	fmt.Println(ls)

	lsl := []string{"周", "啊", "饿", "博", "得", "次"} //根据字节排序
	fmt.Println(lsl)
	sort.Strings(lsl)
	fmt.Println(lsl)

	for _, v := range lsl {
		fmt.Println(v, []byte(v))
	}

	/*复杂结构：[][]int
		type testSlice [][]int

		func (l testSlice) Len() int {
			return len(l)
		}
		func (l testSlice) Swap(i, j int) {
			l[i], l[j] = l[j], l[i]
		}
		func (l testSlice) Less(i, j int) bool {
			return l[i][1] < l[j][1]
		}

		ls := testSlice{
			{1, 4},
			{9, 3},
			{7, 5},
		}

		fmt.Println(ls)
		sort.Sort(ls)
		fmt.Println(ls)
		复杂结构体：[]map[string]int [{"k":0}, {"k1":1}, {"k2":2}]
	type testSlice []map[string]float64

	func (l testSlice) Len() int           { return len(l) }
	func (l testSlice) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
	func (l testSlice) Less(i, j int) bool { return l[i]["a"] < l[j]["a"] } // 按照"a"对应的值排序

	func main() {
		ls := testSlice{
			{"a": 4, "b": 12},
			{"a": 3, "b": 11},
			{"a": 5, "b": 10},
		}

		fmt.Println(ls)
		sort.Sort(ls)
		fmt.Println(ls)
	}
	复杂结构体：[]struct


	type People struct {
		Name string
		Age  int
	}

	type testSlice []People

	func (l testSlice) Len() int           { return len(l) }
	func (l testSlice) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
	func (l testSlice) Less(i, j int) bool { return l[i].Age < l[j].Age }

	func main() {
		ls := testSlice{
			{Name: "n1", Age: 12},
			{Name: "n2", Age: 11},
			{Name: "n3", Age: 10},
		}

		fmt.Println(ls)
		sort.Sort(ls)
		fmt.Println(ls)*/
}
